package com.dkd.day20250715;

import java.util.*;

public class Main20 {
    public static void main(String[] args) {
        //给定一组数字，表示扑克牌的牌面数字，忽略扑克牌的花色，请按如下规则对这一组扑克牌进行整理：
        //
        //步骤1. 对扑克牌进行分组，形成组合牌，规则如下：
        //
        //当牌面数字相同张数大于等于4时，组合牌为“炸弹”；
        //3张相同牌面数字 + 2张相同牌面数字，且3张牌与2张牌不相同时，组合牌为“葫芦”；
        //3张相同牌面数字，组合牌为“三张”；
        //2张相同牌面数字，组合牌为“对子”；
        //剩余没有相同的牌，则为“单张”；
        //步骤2. 对上述组合牌进行由大到小排列，规则如下：
        //
        //不同类型组合牌之间由大到小排列规则：“炸弹” > “葫芦” > “三张” > “对子” > “单张”；
        //相同类型组合牌之间，除“葫芦”外，按组合牌全部牌面数字加总由大到小排列；
        //“葫芦”则先按3张相同牌面数字加总由大到小排列，3张相同牌面数字加总相同时，再按另外2张牌面数字加总由大到小排列；
        //由于“葫芦”>“三张”，因此如果能形成更大的组合牌，也可以将“三张”拆分为2张和1张，其中的2张可以和其它“三张”重新组合成“葫芦”，剩下的1张为“单张”
        //步骤3. 当存在多个可能组合方案时，按如下规则排序取最大的一个组合方案：
        //
        //依次对组合方案中的组合牌进行大小比较，规则同上；
        //当组合方案A中的第n个组合牌大于组合方案B中的第n个组合牌时，组合方案A大于组合方案B；
        //输入描述
        //第一行为空格分隔的N个正整数，每个整数取值范围[1,13]，N的取值范围[1,1000]
        //
        //输出描述
        //经重新排列后的扑克牌数字列表，每个数字以空格分隔
        Scanner sc = new Scanner(System.in);
        int [] arr = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        solve(arr);

    }

    public static void solve(int[] arr){
        Integer[] temp = new Integer[arr.length];
        for (int i = 0; i < arr.length; i++) {
            temp[i] = arr[i];
        }
        Arrays.sort(temp, (a, b) -> b-a);

        //
        ArrayList<Integer[]> bomb = new ArrayList<>();
        ArrayList<Integer> three = new ArrayList<>();
        ArrayList<Integer[]> hulu = new ArrayList<>();
        ArrayList<Integer> two = new ArrayList<>();
        ArrayList<Integer> one = new ArrayList<>();

        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            if(map.containsKey(arr[i])){
                map.put(arr[i],map.get(arr[i])+1);
            }else{
                map.put(arr[i],1);
            }
        }


        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            if(entry.getValue() == 1){
                one.add(entry.getKey());
            }else if(entry.getValue() == 2){
                two.add(entry.getKey());
            }else if(entry.getValue() == 3){
                three.add(entry.getKey());
            }else if(entry.getValue() >= 4){
                bomb.add(new Integer[]{entry.getKey(),entry.getValue()});
            }
        }

        //再次逆序

        one.sort((a,b)->b-a);
        two.sort((a,b)->b-a);
        three.sort((a,b)->b-a);

        bomb.sort((a,b) -> b[1]-a[1]==0?b[0]-a[0]:b[1]-a[1]);

        while (three.size() > 0){
            if(three.size() == 1 && two.size() == 0) break;

            int threeNumber = three.remove(0);
            int tempNumber = 0;
            if(two.size() == 0 || (three.size() >= 1 && two.get(0) < three.get(0))){
                tempNumber = three.remove(0);
                hulu.add(new Integer[]{threeNumber,tempNumber});
                one.add(tempNumber);
            }else{
                hulu.add(new Integer[]{threeNumber,two.remove(0)});
            }
        }


        hulu.sort((a,b)->b[0]-a[0]);
        //打印
        for(Integer[] integers: bomb){
            int n = integers[1];
            for(int i = 0;i<n;i++){
                System.out.print(integers[0]+" ");
            }
        }

        for(Integer[] integers: hulu){
            int i = integers[0];
            int j = integers[1];
            for(int m = 0;m<3;m++){
                System.out.print(i+" ");
            }
            System.out.print(j+" ");
            System.out.print(j+" ");
        }

        for(Integer integer: three){
            System.out.print(integer+" ");
            System.out.print(integer+" ");
            System.out.print(integer+" ");
        }

        for(Integer integer: two){
            System.out.print(integer+" ");
            System.out.print(integer+" ");
        }

        for(Integer integer: one){
            System.out.print(integer+" ");
        }

    }
}
